#![allow(non_snake_case)]
use leptos::*;
use server_fn::ServerFnError;
use shq_common::prelude::{ MenuItem, Permission, Role, TreeNode };



// 获取菜单
#[server(FetchTopMenus, "/api")]
pub async fn fetch_top_menus() -> Result<Vec<MenuItem>, ServerFnError> {
    use shq_pas_backend::get_menus;
    let res = get_menus().or_else(|err| {
        return Err(ServerFnError::new(err.to_string()));
    })?;
    Ok(res)
}
// 获取用户角色
#[server(Getrole, "/api")]
pub async fn get_role() -> Result<Vec<Role>, ServerFnError> {
    use shq_pas_backend::get_roles;
    let res = get_roles().await.map_err(|e| {
        ServerFnError::new(format!("获取角色失败：{}", e))
    })?;
    Ok(res)
}
// 获取用户
#[server(FetchTopUser, "/api")]
pub async fn fetch_top_user() -> Result<Vec<TreeNode>, ServerFnError> {
    use shq_pas_backend::get_user;
    let res = get_user().await.map_err(|e| { ServerFnError::new(format!("获取员工失败：{}", e)) })?;
    Ok(res)
}

// 通过角色ID获取权限
#[server(GetRoleMenus, "/api")]
pub async fn get_role_menus(role_id: u32) -> Result<Vec<String>, ServerFnError> {
    use shq_pas_backend::get_role_perms;
    let res = get_role_perms(role_id).await.map_err(|e| {
        ServerFnError::new(format!("获取角色菜单失败：{}", e))
    })?;
    let mut menu_ids = Vec::new();
    
    for (menu_id, permission) in res {
        // 添加操作权限子节点
        for (_, auth_type) in permission.auth_types.iter().enumerate() {
            // 这里假设 auth_type 的类型是 AuthType
            let at:u8 = auth_type.clone().into();
            menu_ids.push(format!("{}_auth_{}", menu_id, at));
        }
        // 添加行级权限子节点
        for (_, row_range) in permission.row_ranges.iter().enumerate() {
            let rr:u8 = row_range.clone().into();
            menu_ids.push(format!("{}_row_{}", menu_id, rr));
        }
        // 添加列级权限子节点
        for (_, column_range) in permission.column_ranges.iter().enumerate() {
            let cr:u8 = column_range.clone().into();
            menu_ids.push(format!("{}_col_{}", menu_id, cr));
        }
    }
    Ok(menu_ids)
}

// 通过用户ID获取权限
#[server(GetUserMenus, "/api")]
pub async fn get_user_menus(user_id: u32) -> Result<Vec<String>, ServerFnError> {
    use shq_pas_backend::get_user_perms;
    let mut menu_ids = Vec::new();
    let res = get_user_perms(user_id).await.map_err(|e| {
        ServerFnError::new(format!("获取角色菜单失败：{}", e))
    })?;
    if res.len() == 0 {
        let roles =  get_user_roles(user_id).await.map_err(|e| {
            ServerFnError::new(format!("获取用户角色失败：{}", e))
        })?;
        if roles.len() != 0 {
            for role_id in roles {
                let role_menus = get_role_menus(role_id).await.map_err(|e| {
                    ServerFnError::new(format!("获取角色菜单失败：{}", e))
                })?;
                menu_ids.extend(role_menus);
            }
        }
    }
    for (menu_id, permission) in res {
        // 添加操作权限子节点
        for (_, auth_type) in permission.auth_types.iter().enumerate() {
            // 这里假设 auth_type 的类型是 AuthType
            let at:u8 = auth_type.clone().into();
            menu_ids.push(format!("{}_auth_{}", menu_id, at));
        }
        // 添加行级权限子节点
        for (_, row_range) in permission.row_ranges.iter().enumerate() {
            let rr:u8 = row_range.clone().into();
            menu_ids.push(format!("{}_row_{}", menu_id, rr));
        }
        // 添加列级权限子节点
        for (_, column_range) in permission.column_ranges.iter().enumerate() {
            let cr:u8 = column_range.clone().into();
            menu_ids.push(format!("{}_col_{}", menu_id, cr));
        }
    }
    Ok(menu_ids)
}

// 通过角色id获取用户
#[server(GetRoleUsers, "/api")]
pub async fn get_role_users(role_id: u32) -> Result<Vec<u32>, ServerFnError> {
    use shq_pas_backend::get_role_users;
    let res = get_role_users(role_id).await.map_err(|e| {
        ServerFnError::new(format!("获取角色菜单失败：{}", e))
    })?;
    Ok(res)
}
// 通过用户id获取角色
#[server(GetUserRoles, "/api")]
pub async fn get_user_roles(user_id: u32) -> Result<Vec<u32>, ServerFnError> {
    use shq_pas_backend::get_user_roles;
    let res = get_user_roles(user_id).await.map_err(|e| {
        ServerFnError::new(format!("获取用户角色失败：{}", e))
    })?;
    Ok(res)
}
// 保存角色菜单权限
#[server(SaveRoleMenus, "/api")]
pub async fn save_role_menus(role_id: u32,perms: Vec<(u32,Permission)>) -> Result<(), ServerFnError> {
    use shq_pas_backend::save_role_perms;
    let res = save_role_perms(role_id, perms).await.map_err(|e| {
        ServerFnError::new(format!("保存角色菜单权限失败：{}", e))
    })?;
    Ok(res)
}
// 保存用户菜单权限
#[server(SaveUserMenus, "/api")]
pub async fn save_user_menus(user: u32,perms: Vec<(u32,Permission)>) -> Result<(), ServerFnError> {
    use shq_pas_backend::save_user_perms;
    let res = save_user_perms(user, perms).await.map_err(|e| {
        ServerFnError::new(format!("保存角色菜单权限失败：{}", e))
    })?;
    Ok(res)
}
// 保存角色用户权限
#[server(SaveRoleUsers, "/api")]
pub async fn save_role_users(role_id: u32, user_ids: Vec<u32>) -> Result<(), ServerFnError> {
    use shq_pas_backend::save_role_users;
    let res = save_role_users(role_id, user_ids).await.map_err(|e| {
        ServerFnError::new(format!("保存角色用户权限失败：{}", e))
    })?;
    Ok(res)
}
// 保存用户角色权限
#[server(SaveUserRoles, "/api")]
pub async fn save_user_roles(user_id: u32, role_ids: Vec<u32>) -> Result<(), ServerFnError> {
    use shq_pas_backend::save_user_roles;
    let res = save_user_roles(user_id, role_ids).await.map_err(|e| {
        ServerFnError::new(format!("保存角色用户权限失败：{}", e))
    })?;
    Ok(res)
}
// 清除角色权限
#[server(ClearRoleMenus, "/api")]
pub async fn del_role(role_id: u32) -> Result<(), ServerFnError> {
    use shq_pas_backend::del_role;
    let res = del_role(role_id).await.map_err(|e| {
        ServerFnError::new(format!("清除角色权限失败：{}", e))
    })?;
    Ok(res)
}
// 清除用户权限
#[server(ClearUserMenus, "/api")]
pub async fn del_user(user_id: u32) -> Result<(), ServerFnError> {
    use shq_pas_backend::del_user;
    let res = del_user(user_id).await.map_err(|e| {
        ServerFnError::new(format!("清除角色权限失败：{}", e))
    })?;
    Ok(res)
}